Il Rinfresco delle finestre

Come voi tutti sapete le finestre possono essere spostate, ingrandite,
rimpicciolite, fatte scivolare una davanti all'altra ecc.; il sistema di
Amiga è progettato in maniera così flessibile che tutto ciò è gestito in
maniera trasparente all'applicazione; vale a dire che l'applicazione disegna
all'interno della finestra sempre nella stessa maniera e con le stesse
cordinate, indipendentemente dalla posizione o grandezza di quest'ultima; un
problemma tuttavia permane: cosa succede quando una zona oscurata da
un'altra finestra viene riportata alla luce? In tal caso il sistema informa
l'applicazione, mediante un messaggio IDCMP_REFRESHWINDOW alla porta IDCMP
della finestra; l'applicazione una volta ricevuto questo messaggio, deve
effettuare una chiamate BeginRefresh(), procedere con i dovuti rinfreschi al
contenuto della finestra e chiamare EndRefresh(); nel caso non si debba
effettuare alcun rinfresco, bisogna comunque chiamare la coppia delle
funzioni appena viste senza alcuna istruzione al loro interno; sintassi di
queste due funzioni è:

BeginRefresh(finestra);

dove "finestra" è il puntatore alla finestra di cui effettuare il rinfresco;

EndRefresh(finestra,finito);

"finestra" è la stessa della BeginRefresh corrispondente, "finito" è una
variabile booleana e vale TRUE se il rinfresco è stato ultimato; FALSE se il
rinfresco non è finito, allora il sistema mantiene bloccato il layer della
finestra fino a quando non si esegue una coppia BeginRefresh/EndRefresh con
"finito" impostato a TRUE; vi chiederete perchè spezzettare l'operazione di
rinfresco in diversi blocchi: durante il rinfresco il sistema attende, per
cui è IMPORTANTE che il codice del blocco di rinfresco sai molto veloce;
spezzettando l'operazione di rinfresco in più sezioni, è agevole ripassare
il controllo al sistema senza bloccarlo per un tempo esagerato.
Se non desiderate effettuare alcun rinfresco e quindi chiamare le due
istruzioni appena indicate, oppure volete far realizzare il rinfresco
totalmente al sistema, potete impostare il flag WA_NoCareRefresh.
Esistono tre tipi differenti di rinfresco organizzati dal sistema, ognuno
con livello di efficienza e anche di consumo crescente:

Simple refresh
Simple refresh è il rinfresco più semplice: vengono mantenuti e rinfrescati
tutti quei pixels che sono visualizzati sullo schermo; ad esempio, se una
finestra viene spostata, il suo contenuto viene ricopiato; i problemi si
verificano quando un'altra finestra passa davanti a quella "rinfrescata" in
quanto il suo contenuto viene oscurato, per cui se la finestra viene
spostata o riportata in avanti, la zona oscurata non viene rinfrescata.
Questo tipo di rinfresco si attiva impostando WFLG_SIMPLE_REFRESH nel tag
WA_Flags.

Smart refresh
Nella finestra Smart refresh il sistema mantiene e rinfresca tutto il
contenuto della finestra; nel caso visto prima, anche se la finestra con
questo tipo di rinfresco viene oscurata, quando viene riportata alla luce
la zona prima non visibile, viene correttamente ridisegnata; questo
rinfresco si attiva impostando WFLG_SMART_REFRESH nel tag WA_Flags.

SuperBitMap refresh
Nelle finestre SuperBitMap l'utente specifica il BitMap (struttura che
contiene le informazione per un'immagine o uno spazio grafico) che il
sistema utilizzerà per il rinfresco della finestra; questo tipo di finestra
serve quando quest'ultima può essere più piccola dell'immagine (nel qual
caso la finestra mostra solo una porzione dell'immagine); ad esempio se si
utilizza una finestra ridimensionabile, si disegna qualcosa e la si riduce,
quando si riallarga la zona dell'immagine oscurata dal rimpicciolimento
della finestra viene rinfrescata; naturalmente questo tipo di finestra si
propone anche per altri utilizzi, quali ad esempio lo scorrimento di
un'immagine più grande nella stessa, come fa MultiView; normalmente una
finestra SuperBitMap è anche GimmeZeroZero, in modo da avere due layer
differenti, uno per il contenuto e uno per il bordo; questo tipo di finestra
si imposta con WFLG_SUPER_BITMAP in WA_Flags.

Mentre per i primi due rinfreschi serve semplicemente impostare il flag
indicato ed il resto sarà compito del sistema, nella finestra SuperBitMap
occorre allocare ed inizializzare una struttura BitMap nostra e passarla al
tag WA_SuperBitMap all'apertura della finestra; per inizializzare una BitMap
occorre allocare una struttura BitMap, inizializzarne i campi con la
funzione:

InitBitMap(bitmap,profondità,ampiezza,altezza);

dove "bitmap" è il puntatore alla struttura BitMap da inizializzare,
"profondità", "ampiezza" e "altezza" sono LONG indicanti la dimensione della
bitmap; una volta inizializzata la bitmap, occorre allocare la memoria che
contiene i piani dei bit dell'immagine mediante la funzione:

puntpiano = AllocRaster(ampiezza,altezza);

bisogna chiamare questa funzione per ogni bitplane da allocare, il cui
puntatore è restituito in "puntpiano" che è di tipo PLANEPTR; questi
puntatori dovranno essere inseriti nel campo vettore Planes della struttura
BitMap; all'uscita del programma bisogna deallocare i bitplanes con

FreeRaster(puntpiano,ampiezza,altezza);